home *** CD-ROM | disk | FTP | other *** search
/ SGI Developer Toolbox 6.1 / SGI Developer Toolbox 6.1 - Disc 4.iso / src / exampleCode / games / IndiZone / vroom / Row.c < prev    next >
Encoding:
C/C++ Source or Header  |  1994-08-02  |  13.8 KB  |  532 lines
  1. /*******************************************************************************
  2.  * Row.c: Methods for the Row widget
  3.  *         From:
  4.  *                   The X Window System, 
  5.  *            Programming and Applications with Xt
  6.  *                   OSF/Motif Edition
  7.  *         by
  8.  *                Douglas Young
  9.  *              Prentice Hall, 1990
  10.  *
  11.  *                 Example described on pages: 375-390
  12.  *
  13.  * Modified slightly by Chris Fouts, Silicon Graphics, Inc. 1994
  14.  *
  15.  *  Copyright 1989 by Prentice Hall
  16.  *  All Rights Reserved
  17.  *
  18.  * This code is based on the OSF/Motif widget set and the X Window System
  19.  *
  20.  * Permission to use, copy, modify, and distribute this software for 
  21.  * any purpose and without fee is hereby granted, provided that the above
  22.  * copyright notice appear in all copies and that both the copyright notice
  23.  * and this permission notice appear in supporting documentation.
  24.  *
  25.  * Prentice Hall and the author disclaim all warranties with regard to 
  26.  * this software, including all implied warranties of merchantability and
  27.  * fitness.  In no event shall Prentice Hall or the author be liable for any
  28.  * special, indirect or cosequential damages or any damages whatsoever
  29.  * resulting from  loss of use, data or profits, whether in an action of
  30.  * contract, negligence  or other tortious action, arising out of or in
  31.  * connection with the use  or performance of this software.
  32.  *
  33.  * Open Software Foundation is a trademark of The Open Software Foundation, Inc.
  34.  * OSF is a trademark of Open Software Foundation, Inc.
  35.  * OSF/Motif is a trademark of Open Software Foundation, Inc.
  36.  * Motif is a trademark of Open Software Foundation, Inc.
  37.  * DEC is a registered trademark of Digital Equipment Corporation
  38.  * HP is a registered trademark of the Hewlett Packard Company
  39.  * DIGITAL is a registered trademark of Digital Equipment Corporation
  40.  * X Window System is a trademark of the Massachusetts Institute of Technology
  41.  ******************************************************************************/
  42.  
  43.  
  44. #include    <stdio.h>
  45. #include    <X11/IntrinsicP.h>
  46. #include    <X11/Intrinsic.h>
  47. #include    <X11/Composite.h>
  48. #include    <X11/CompositeP.h>
  49. #include    <X11/Xm/XmStrDefs.h>
  50. #include    "RowP.h"
  51. #include    "Row.h"
  52. #define MAX(a,b) ((a) > (b) ? (a) : (b))
  53. #define MIN(a,b) ((a) < (b) ? (a) : (b))
  54.  
  55. /* BEGIN PROTOTYPES -S Row.c */
  56. static void                 ChangeManaged( Widget w ) ;
  57. static void                 do_layout( XsRowWidget parent ) ;
  58. static XtGeometryResult     GeometryManager( Widget w,
  59.                                 XtWidgetGeometry *request,
  60.                                 XtWidgetGeometry *reply ) ;
  61. static void                 Initialize( Widget request, Widget new,
  62.                                 ArgList args, Cardinal *numArgs ) ;
  63. static XtGeometryResult     PreferredSize( Widget w,
  64.                                 XtWidgetGeometry *request,
  65.                                 XtWidgetGeometry *preferred ) ;
  66. static void                 Resize( Widget w ) ;
  67. static XtGeometryResult     try_layout( XsRowWidget parent, Mask *mask,
  68.                                 Dimension *w_delta, Dimension *h_delta ) ;
  69. /* END PROTOTYPES -S Row.c */
  70.  
  71. static XtResource    resources[] =
  72.         {
  73.         {    XmNspacing, XmCSpacing, XtRInt, sizeof( int ),
  74.             XtOffset( XsRowWidget, row.spacing ), XtRString, "5" },
  75.         } ;
  76.  
  77.  
  78. XsRowClassRec XsrowClassRec = {
  79.     {
  80.     /* core_class members      */
  81.     (WidgetClass) &compositeClassRec, /* superclass         */
  82.     "Row",                            /* class_name         */
  83.     sizeof(XsRowRec),                 /* widget_size        */
  84.     NULL,                             /* class_initialize   */
  85.     NULL,                             /* class_part_init    */    
  86.     FALSE,                            /* class_inited       */    
  87.     Initialize,                       /* initialize         */
  88.     NULL,                             /* initialize_hook    */    
  89.     XtInheritRealize,                 /* realize            */
  90.     NULL,                             /* actions            */
  91.     0,                                /* num_actions        */    
  92.     resources,                        /* resources          */
  93.     XtNumber( resources ),            /* num_resources      */
  94.     NULLQUARK,                        /* xrm_class          */
  95.     TRUE,                             /* compress_motion    */    
  96.     TRUE,                             /* compress_exposure  */    
  97.     TRUE,                             /* compress_enterleave*/    
  98.     FALSE,                            /* visible_interest   */
  99.     NULL,                             /* destroy            */
  100.     Resize,                           /* resize             */
  101.     NULL,                             /* expose             */
  102.     NULL,                             /* set_values         */
  103.     NULL,                             /* set_values_hook    */
  104.     XtInheritSetValuesAlmost,         /* set_values_almost  */
  105.     NULL,                             /* get_values_hook    */    
  106.     NULL,                             /* accept_focus       */
  107.     XtVersion,                        /* version            */    
  108.     NULL,                             /* callback_private   */
  109.     NULL,                             /* tm_table           */
  110.     PreferredSize,                    /* query_geometry     */    
  111.     NULL,                             /* display_accelerator*/
  112.     NULL,                             /* extension          */
  113.     },
  114.     {
  115.     /* composite_class members */
  116.     GeometryManager,                  /* geometry_manager   */
  117.     ChangeManaged,                    /* change_managed     */
  118.     XtInheritInsertChild,             /* insert_child       */    
  119.     XtInheritDeleteChild,             /* delete_child       */    
  120.     NULL,                             /* extension          */
  121.     },
  122.     {
  123.     /* Row class members */
  124.     0,                                /* empty              */    
  125.     }
  126. };
  127.  
  128.  
  129. WidgetClass xsRowWidgetClass = (WidgetClass) &XsrowClassRec;
  130.  
  131.  
  132. static void
  133. Initialize(
  134.     Widget        request,
  135.     Widget        new,
  136.     ArgList        args,
  137.     Cardinal    *numArgs
  138.     )
  139. {
  140.     XsRowWidget    reqRow = (XsRowWidget)request ;
  141.     XsRowWidget    newRow = (XsRowWidget)new ;
  142.  
  143.     if( reqRow->core.width <= 0 )
  144.     {
  145.         newRow->core.width = 5 ;
  146.     }
  147.     if( reqRow->core.height <= 0 )
  148.     {
  149.         newRow->core.height = 5 ;
  150.     }
  151.     if( reqRow->row.spacing < 0 )
  152.     {
  153.         newRow->row.spacing = 5 ;
  154.     }
  155. } 
  156.  
  157.  
  158.  
  159. static void
  160. Resize(
  161.     Widget    w
  162.     )
  163. {
  164.     do_layout( (XsRowWidget)w ) ;
  165. } 
  166.  
  167.  
  168.  
  169. static void
  170. do_layout(
  171.     XsRowWidget    parent
  172.     )
  173. {
  174.     Widget        child ;
  175.     int        i ;
  176.     Dimension    childwidth = 2 * parent->row.spacing ;
  177.     Position    xpos = parent->row.spacing ;
  178.     Dimension    pad = 0 ;
  179.     int        n_managed_children = 0 ;
  180.  
  181.     /*
  182.      * Compute the total width of all managed children and
  183.      * determine how many children are managed.
  184.      */
  185.     for( i = 0 ; i < parent->composite.num_children ; i++ )
  186.     {
  187.         child = parent->composite.children[i] ;
  188.         if( child->core.managed )
  189.         {
  190.             n_managed_children++;
  191.             childwidth += child->core.width + 
  192.                     child->core.border_width * 2 ;
  193.         }
  194.     }
  195.     /*
  196.      *  Divide any remaining space by the number 
  197.      *  of children.
  198.      */
  199.     if( ( n_managed_children > 1 ) && ( parent->core.width > childwidth ) )
  200.     {
  201.         pad = ( parent->core.width - childwidth ) /
  202.             ( n_managed_children - 1 ) ;
  203.     }
  204.     /*
  205.      * Position all children.
  206.      */
  207.     for( i = 0 ; i < parent->composite.num_children ; i++ )
  208.     {
  209.         child = parent->composite.children[i] ;
  210.         if( child->core.managed )
  211.         {
  212.             XtMoveWidget( child, xpos, parent->row.spacing ) ;
  213.             xpos += pad + child->core.width + 
  214.                      child->core.border_width * 2 ;
  215.         }
  216.     }
  217. }
  218.  
  219.  
  220.  
  221. static XtGeometryResult
  222. PreferredSize(
  223.     Widget            w,
  224.     XtWidgetGeometry    *request,
  225.     XtWidgetGeometry    *preferred
  226.     )
  227. {
  228.     XsRowWidget    row = (XsRowWidget)w ;
  229.     Widget        child ;
  230.     int        i ;
  231.  
  232.     /*
  233.      * If no changes are being made to width or 
  234.      * height, just agree. 
  235.      */
  236.     if( !( request->request_mode & CWWidth ) &&
  237.         !( request->request_mode & CWHeight ) )
  238.     {
  239.         return( XtGeometryYes ) ;
  240.     }
  241.  
  242.     /*
  243.      * Calculate our minimum size.
  244.      */
  245.     preferred->width = row->row.spacing ;
  246.     preferred->height = 0 ;       
  247.     for( i = 0 ; i < row->composite.num_children; i++ )
  248.     {
  249.         child = row->composite.children[i] ;
  250.         if( child->core.managed )
  251.         {
  252.             Dimension    h ;
  253.  
  254.             preferred->width += child->core.width + 
  255.                     child->core.border_width * 2 +
  256.                     row->row.spacing ;
  257.             h = child->core.height + child->core.border_width * 2 +
  258.                 row->row.spacing * 2 ;
  259.             if( preferred->height < h )
  260.             {
  261.                 preferred->height = h ;
  262.             }
  263.         }
  264.     }
  265.     preferred->request_mode = CWWidth | CWHeight;
  266.  
  267.     /* 
  268.      * If both width and height are requested.
  269.      */
  270.     if( ( request->request_mode & CWWidth ) && 
  271.         ( request->request_mode & CWHeight ) )
  272.     {
  273.         /* 
  274.          * If we are to be the same or bigger, say ok.
  275.          */
  276.         if( preferred->width <= request->width &&
  277.             preferred->height <= request->height )
  278.         {
  279.             preferred->width  = request->width;
  280.             preferred->height = request->height;
  281.             return( XtGeometryYes ) ;
  282.         }
  283.         /*
  284.          * If both dimensions are unacceptable, say no.
  285.          */
  286.         else if( preferred->width < request->width && 
  287.             preferred->height < request->height )
  288.         {
  289.             return( XtGeometryNo ) ;
  290.         }
  291.         /*
  292.          * Otherwise one must be right, so say almost.
  293.          */
  294.         else
  295.         {
  296.             return( XtGeometryAlmost ) ;
  297.         }
  298.     }
  299.     /*
  300.      * If only the width is requested, either it's 
  301.      * OK or it isn't. Same for height.
  302.      */
  303.     else if( request->request_mode & CWWidth )
  304.     {
  305.         if( preferred->width <= request->width )
  306.         {
  307.             preferred->width = request->width ;
  308.             return( XtGeometryYes ) ;
  309.         } 
  310.         else
  311.         {
  312.             return( XtGeometryNo ) ;
  313.         }
  314.     }
  315.     else if(request->request_mode & CWHeight)
  316.     {
  317.         if( preferred->height <= request->height )
  318.         {
  319.             preferred->height = request->height ;
  320.             return( XtGeometryYes ) ;
  321.         }
  322.         else
  323.         {
  324.             return( XtGeometryNo ) ;
  325.         }
  326.     }
  327.     return( XtGeometryYes ) ;
  328. }
  329.  
  330.  
  331.  
  332. static XtGeometryResult
  333. GeometryManager(
  334.     Widget            w,
  335.     XtWidgetGeometry    *request,
  336.     XtWidgetGeometry    *reply
  337.     )
  338. {
  339.     XsRowWidget        rw = (XsRowWidget)( w->core.parent ) ;
  340.     Mask            mask ;
  341.     XtGeometryResult    result ;
  342.     Dimension        wdelta ;
  343.     Dimension        hdelta ;
  344.  
  345.     /*
  346.      * Say no.  We control the vertical....
  347.      */
  348.     if( ( request->request_mode & CWX && request->x != w->core.x ) ||
  349.         ( request->request_mode & CWY && request->y != w->core.y ) )
  350.     {
  351.         return( XtGeometryNo ) ;
  352.     }
  353.     /*
  354.      *  Otherwise, grant all requests if they fit.
  355.      */
  356.     if( request->request_mode & ( CWWidth | CWHeight | CWBorderWidth ) )
  357.     {
  358.         /*
  359.          * Save the original widget size, and set the 
  360.          * corresponding widget fields to the requested sizes.
  361.          */
  362.         Dimension savewidth       = w->core.width;
  363.         Dimension saveheight      = w->core.height;
  364.         Dimension saveborderwidth = w->core.border_width;
  365.  
  366.         if( request->request_mode & CWWidth )
  367.         {
  368.             w->core.width = request->width ;
  369.         }
  370.         if( request->request_mode & CWHeight )
  371.         {
  372.             w->core.height = request->height ;
  373.         }
  374.         if( request->request_mode & CWBorderWidth )
  375.         {
  376.             w->core.border_width = request->border_width ;
  377.         }
  378.         /*
  379.          * See if we can still handle all the children 
  380.          * if the request is granted.
  381.          */
  382.         result = try_layout( rw, &mask, &wdelta, &hdelta ) ;
  383.         /*
  384.          * If the children won't fit, restore the widget to its
  385.          * original size, and return no.
  386.          */
  387.         if( result == XtGeometryNo )
  388.         {
  389.             w->core.width  = savewidth ;
  390.             w->core.height = saveheight ;
  391.             w->core.border_width = saveborderwidth ;
  392.             return( XtGeometryNo ) ;
  393.         }
  394.         /*
  395.          * If only one dimension fits, restore the one that
  396.          * doesn't fit and return "almost".
  397.          */
  398.         if( result == XtGeometryAlmost )
  399.         {
  400.             reply->request_mode = request->request_mode ;
  401.             if( !( mask & CWWidth ) )
  402.             {
  403.                 reply->width = w->core.width = savewidth ;
  404.                 reply->border_width  = saveborderwidth ;
  405.                 w->core.border_width = saveborderwidth ;
  406.             }
  407.             if( !( mask & CWHeight ) )
  408.             {
  409.                 reply->height = w->core.height = saveheight ;
  410.             }
  411.  
  412.             return( XtGeometryAlmost ) ;
  413.         }
  414.         /*
  415.          * If we got here, everything must fit, so reposition
  416.          * all children based on the new size, and return "yes".
  417.          */
  418.         do_layout( rw ) ;
  419.         return( XtGeometryYes ) ;
  420.     }
  421.     return( XtGeometryYes ) ;
  422. }
  423.  
  424.  
  425.  
  426. static XtGeometryResult 
  427. try_layout(
  428.     XsRowWidget    parent,
  429.     Mask        *mask,
  430.     Dimension    *w_delta,
  431.     Dimension    *h_delta
  432.     )
  433. {
  434.     int        i ;
  435.     Dimension    total_width = 2 * parent->row.spacing ;
  436.     Dimension    max_height = 2 * parent->row.spacing ;
  437.  
  438.     /*
  439.      * Get the bounding width and height of all children.
  440.      */
  441.     for( i = 0 ; i < parent->composite.num_children ; i++ )
  442.     {
  443.         Widget        child ;
  444.         Dimension    width ;
  445.         Dimension    height ;
  446.  
  447.         child = parent->composite.children[i] ;
  448.         if( child->core.managed )
  449.         {
  450.             height = child->core.height +
  451.                     child->core.border_width * 2 +
  452.                     parent->row.spacing * 2 ;
  453.             width  = child->core.width +
  454.                     child->core.border_width * 2 ;
  455.             total_width += width ;
  456.             max_height = MAX( max_height, height ) ;
  457.         }
  458.     }
  459.     if( parent->composite.num_children > 1 )
  460.     {
  461.         total_width += ( parent->composite.num_children - 1 ) *
  462.             parent->row.spacing ;
  463.     }
  464.  
  465.     /*
  466.      *  If everyone doesn't fit, ask if we can grow. Return the 
  467.      *  result, after setting the mask to indicate which (if 
  468.      *  any) dimension is ok.
  469.      */
  470.     if( total_width > parent->core.width || 
  471.         max_height > parent->core.height )
  472.     {
  473.         XtGeometryResult    result ;
  474.         Dimension        replyWidth ;
  475.         Dimension        replyHeight ;
  476.         Dimension    width  = MAX(total_width, parent->core.width);
  477.         Dimension    height = MAX(max_height, parent->core.height);
  478.  
  479.         result = XtMakeResizeRequest( (Widget)parent, width, height,
  480.                         &replyWidth, &replyHeight ) ;
  481.         *mask = NULL ;
  482.         if( total_width == replyWidth )
  483.         {
  484.             *mask  = CWWidth ;
  485.         }
  486.         if( max_height == replyHeight )
  487.         {
  488.             *mask |= CWHeight ;
  489.         }
  490.  
  491.         if( result == XtGeometryAlmost )
  492.         {
  493.             XtMakeResizeRequest( (Widget)parent, replyWidth,
  494.                         replyHeight, NULL, NULL) ;
  495.         }
  496.         *w_delta = total_width - parent->core.width;
  497.         *h_delta = max_height - parent->core.height;
  498.         return( result ) ;
  499.     }
  500.     /*
  501.      * If everybody fits, just return yes.
  502.      */
  503.     *mask = CWWidth | CWHeight ;
  504.     return( XtGeometryYes ) ;
  505. }
  506.  
  507.  
  508.  
  509. static void
  510. ChangeManaged(
  511.     Widget    w
  512.     )
  513. {
  514.     XsRowWidget        row = (XsRowWidget)w ;
  515.     XtGeometryResult    result;
  516.     Dimension           width, height, delta;
  517.     int                 i;
  518.     Mask                mask;
  519.     Widget              child;
  520.  
  521.     /*
  522.      * See if all children fit.
  523.      */
  524.     result = try_layout( row, &mask, &width, &height ) ;
  525.  
  526.     /*
  527.      * Move all children to their new positions.
  528.      */
  529.     do_layout( row ) ;
  530. }
  531.  
  532.